/**
 * ============================================
 * 数据库初始化脚本
 * 功能：创建数据库和所有必要的表结构，并插入初始测试数据
 * 使用说明：
 * 1. 确保已安装MySQL服务器并正确配置环境变量
 * 2. 运行此脚本：node scripts/init-database.js
 * 3. 脚本会自动创建数据库、表和测试数据
 * ============================================
 */

// 导入mysql2/promise库，提供Promise风格的MySQL操作
const mysql = require('mysql2/promise');

// 导入dotenv库，从.env文件加载环境变量
require('dotenv').config();

/**
 * 数据库初始化主函数
 * 这个函数负责完整的数据库初始化流程：
 * 1. 连接MySQL服务器
 * 2. 创建数据库（如果不存在）
 * 3. 创建所有必要的表结构
 * 4. 插入初始数据
 * 5. 插入测试数据用于开发和测试
 *
 * @returns {Promise<void>}
 */
async function initDatabase() {
  let connection; // 声明连接变量，用于在整个函数中管理数据库连接
  
  try {
    console.log('🚀 开始初始化数据库...');
    
    /**
     * 第一步：连接到MySQL服务器（不指定具体数据库）
     * 因为此时数据库可能还不存在，所以先连接到MySQL服务器实例
     * multipleStatements: true 允许执行多条SQL语句
     */
    connection = await mysql.createConnection({
      host: process.env.DB_HOST,        // 数据库服务器地址
      port: process.env.DB_PORT,        // 数据库服务器端口
      user: process.env.DB_USER,        // 数据库用户名
      password: process.env.DB_PASSWORD, // 数据库密码
      multipleStatements: true          // 启用多语句执行
    });

    console.log('✅ MySQL服务器连接成功');

    /**
     * 第二步：创建数据库（如果不存在）
     * 使用CREATE DATABASE IF NOT EXISTS语句确保数据库存在
     * CHARACTER SET utf8mb4: 支持所有Unicode字符（包括emoji）
     * COLLATE utf8mb4_unicode_ci: 使用Unicode排序规则，不区分大小写
     */
    const dbName = process.env.DB_NAME; // 从环境变量获取数据库名称
    await connection.execute(`CREATE DATABASE IF NOT EXISTS \`${dbName}\` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`);
    console.log(`✅ 数据库 ${dbName} 创建/验证成功`);

    /**
     * 第三步：切换到新创建的数据库
     * 使用USE语句选择要操作的数据库
     * 注意：这里使用connection.query而不是connection.execute
     * 因为USE语句不能使用预处理语句（参数化查询）
     */
    await connection.query(`USE \`${dbName}\``);

    /**
     * ====================
     * 第四步：创建数据表结构
     * 按照业务逻辑顺序创建表，先创建基础表，再创建依赖表
     * ====================
     */

    // ====================
    // 创建用户表 (users)
    // 用户表是系统的基础表，存储用户基本信息
    // ====================
    const createUsersTable = `
      CREATE TABLE IF NOT EXISTS users (
        id INT AUTO_INCREMENT PRIMARY KEY,                           -- 用户ID，自增主键
        username VARCHAR(50) UNIQUE NOT NULL,                        -- 用户名，唯一且不能为空
        email VARCHAR(100) UNIQUE NOT NULL,                          -- 邮箱，唯一且不能为空
        password VARCHAR(255) NOT NULL,                              -- 加密后的密码
        country VARCHAR(10) NOT NULL DEFAULT 'CN',                   -- 国家代码，默认中国
        name VARCHAR(100),                                           -- 用户真实姓名（可选）
        avatar VARCHAR(255),                                         -- 头像URL（可选）
        is_active BOOLEAN DEFAULT TRUE,                              -- 账户是否激活，默认激活
        last_login TIMESTAMP NULL,                                   -- 最后登录时间（可为空）
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,              -- 创建时间，自动设置
        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, -- 更新时间，自动更新
        INDEX idx_username (username),                               -- 为用户名创建索引，加快查询
        INDEX idx_email (email),                                     -- 为邮箱创建索引
        INDEX idx_country (country)                                  -- 为国家代码创建索引
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci  -- 使用InnoDB引擎，支持事务
    `;
    await connection.execute(createUsersTable);
    console.log('✅ 用户表创建成功');

    // ====================
    // 创建国家表 (countries)
    // 存储国家代码和名称的字典表
    // ====================
    const createCountriesTable = `
      CREATE TABLE IF NOT EXISTS countries (
        id INT AUTO_INCREMENT PRIMARY KEY,                    -- 国家ID，自增主键
        code VARCHAR(10) UNIQUE NOT NULL,                     -- 国家代码（如CN,US），唯一
        name VARCHAR(100) NOT NULL,                           -- 国家名称
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP        -- 创建时间
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
    `;
    await connection.execute(createCountriesTable);
    console.log('✅ 国家表创建成功');

    // ====================
    // 创建持卡人允许国家表 (cardholder_allowed_countries)
    // 限制哪些国家的用户可以注册为持卡人
    // ====================
    const createCardholderAllowedCountriesTable = `
      CREATE TABLE IF NOT EXISTS cardholder_allowed_countries (
        id INT AUTO_INCREMENT PRIMARY KEY,                                -- 记录ID，自增主键
        country_code VARCHAR(10) UNIQUE NOT NULL,                         -- 允许的国家代码，唯一
        is_active BOOLEAN DEFAULT TRUE,                                   -- 是否激活该国家
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,                   -- 创建时间
        FOREIGN KEY (country_code) REFERENCES countries(code) ON DELETE CASCADE, -- 外键关联国家表
        INDEX idx_country_code (country_code),                            -- 为国家代码创建索引
        INDEX idx_is_active (is_active)                                   -- 为激活状态创建索引
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
    `;
    await connection.execute(createCardholderAllowedCountriesTable);
    console.log('✅ 持卡人允许国家表创建成功');

    // ====================
    // 创建持卡人表 (cardholders)
    // 存储持卡人的详细信息，每个用户可以关联多个持卡人
    // ====================
    const createCardholdersTable = `
      CREATE TABLE IF NOT EXISTS cardholders (
        id INT AUTO_INCREMENT PRIMARY KEY,                                    -- 持卡人ID，自增主键
        cardholder_id VARCHAR(20) UNIQUE NOT NULL,                            -- 持卡人唯一标识
        user_id INT NOT NULL,                                                 -- 关联的用户ID
        cardholder_name_abbreviation VARCHAR(20) NOT NULL,                    -- 持卡人姓名缩写
        first_name VARCHAR(50) NOT NULL,                                      -- 名字
        last_name VARCHAR(50) NOT NULL,                                       -- 姓氏
        first_name_abbr VARCHAR(10),                                          -- 名字缩写（可选）
        last_name_abbr VARCHAR(10),                                           -- 姓氏缩写（可选）
        email VARCHAR(100) NOT NULL,                                          -- 持卡人邮箱
        mobile_prefix VARCHAR(10) NOT NULL,                                   -- 手机号前缀（如+86）
        mobile VARCHAR(20) NOT NULL,                                          -- 手机号
        date_of_birth DATE NOT NULL,                                          -- 出生日期
        nationality_country_code VARCHAR(10) NOT NULL,                        -- 国籍国家代码
        residential_country_code VARCHAR(10) NOT NULL,                        -- 居住国家代码
        residential_address TEXT NOT NULL,                                    -- 居住地址
        residential_city VARCHAR(100) NOT NULL,                               -- 居住城市
        residential_postal_code VARCHAR(20),                                  -- 邮政编码（可选）
        residential_state VARCHAR(100),                                       -- 州/省份（可选）
        status ENUM('normal', 'disabled', 'failed', 'pending') DEFAULT 'pending', -- 持卡人状态
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,                       -- 创建时间
        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, -- 更新时间
        FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,         -- 外键关联用户表
        INDEX idx_user_id (user_id),                                          -- 为用户ID创建索引
        INDEX idx_cardholder_id (cardholder_id),                              -- 为持卡人ID创建索引
        INDEX idx_email (email),                                              -- 为邮箱创建索引
        INDEX idx_mobile (mobile)                                             -- 为手机号创建索引
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
    `;
    await connection.execute(createCardholdersTable);
    console.log('✅ 持卡人表创建成功');

    // ====================
    // 创建卡片表 (cards)
    // 存储银行卡信息，每张卡关联一个用户和一个持卡人
    // ====================
    const createCardsTable = `
      CREATE TABLE IF NOT EXISTS cards (
        id INT AUTO_INCREMENT PRIMARY KEY,                                    -- 卡片ID，自增主键
        user_id INT NOT NULL,                                                 -- 关联的用户ID
        cardholder_id INT NOT NULL,                                           -- 关联的持卡人ID
        card_number VARCHAR(20) UNIQUE NOT NULL,                              -- 卡号，唯一
        card_bin VARCHAR(10) NOT NULL,                                        -- 卡BIN（前6位）
        card_type ENUM('debit', 'credit') NOT NULL,                           -- 卡类型：借记卡/信用卡
        card_form_factor ENUM('virtual_card', 'physical_card') NOT NULL,      -- 卡形式：虚拟卡/实体卡
        card_scheme VARCHAR(50) NOT NULL,                                     -- 卡组织：VISA/MasterCard等
        currency VARCHAR(10) NOT NULL DEFAULT 'USD',                          -- 货币类型，默认美元
        balance DECIMAL(15,2) DEFAULT 0.00,                                   -- 总余额（包含冻结金额）
        available_balance DECIMAL(15,2) DEFAULT 0.00,                         -- 可用余额
        card_status ENUM('normal', 'pending_recharge', 'unactivated', 'freezing', 'frozen', 'risk_frozen', 'system_frozen', 'unfreezing', 'expired', 'canceling', 'cancelled', 'renewing', 'replacing', 'lost', 'stolen', 'pin_lost') DEFAULT 'normal', -- 卡状态
        nickname VARCHAR(100),                                                -- 卡昵称（可选）
        expiry_date DATE,                                                     -- 过期日期（可选）
        cvv VARCHAR(10),                                                      -- 安全码（可选）
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,                       -- 创建时间
        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, -- 更新时间
        FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,         -- 外键关联用户表
        FOREIGN KEY (cardholder_id) REFERENCES cardholders(id) ON DELETE CASCADE, -- 外键关联持卡人表
        INDEX idx_user_id (user_id),                                          -- 为用户ID创建索引
        INDEX idx_cardholder_id (cardholder_id),                              -- 为持卡人ID创建索引
        INDEX idx_card_number (card_number),                                  -- 为卡号创建索引
        INDEX idx_card_status (card_status)                                   -- 为卡状态创建索引
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
    `;
    await connection.execute(createCardsTable);
    console.log('✅ 卡片表创建成功');

    // ====================
    // 创建充值记录表 (recharges)
    // 存储用户的充值记录，支持多种支付方式
    // ====================
    const createRechargesTable = `
      CREATE TABLE IF NOT EXISTS recharges (
        id INT AUTO_INCREMENT PRIMARY KEY,                                    -- 充值记录ID，自增主键
        user_id INT NOT NULL,                                                 -- 关联的用户ID
        money DECIMAL(15,2) NOT NULL,                                         -- 充值金额（外币）
        exchange_rate DECIMAL(10,4) NOT NULL,                                 -- 汇率
        money_cny DECIMAL(15,2) NOT NULL,                                     -- 换算后的人民币金额
        pay_type TINYINT NOT NULL COMMENT '1:支付宝, 2:微信, 3:银行卡',        -- 支付方式
        voucher VARCHAR(255),                                                 -- 支付凭证（截图URL等）
        remark TEXT,                                                          -- 备注信息
        audit_status TINYINT DEFAULT 0 COMMENT '0:待审核, 1:通过, 2:驳回',     -- 审核状态
        audit_reason TEXT,                                                    -- 审核原因（通过/驳回的原因）
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,                       -- 创建时间
        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, -- 更新时间
        FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,         -- 外键关联用户表
        INDEX idx_user_id (user_id),                                          -- 为用户ID创建索引
        INDEX idx_audit_status (audit_status),                                -- 为审核状态创建索引
        INDEX idx_created_at (created_at)                                     -- 为创建时间创建索引
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
    `;
    await connection.execute(createRechargesTable);
    console.log('✅ 充值记录表创建成功');

    // ====================
    // 创建资金明细表 (money_details)
    // 记录用户资金变动的详细流水
    // ====================
    const createMoneyDetailsTable = `
      CREATE TABLE IF NOT EXISTS money_details (
        id INT AUTO_INCREMENT PRIMARY KEY,                                    -- 流水ID，自增主键
        user_id INT NOT NULL,                                                 -- 关联的用户ID
        change_type TINYINT NOT NULL COMMENT '1:充值, 2:提现, 3:提现驳回, 4:开卡, 5:转入', -- 变动类型
        amount DECIMAL(15,2) NOT NULL,                                        -- 变动金额
        balance DECIMAL(15,2) NOT NULL,                                       -- 变动后余额
        description TEXT,                                                     -- 变动描述
        related_id INT,                                                       -- 关联的业务ID（如充值ID、卡ID等）
        related_type VARCHAR(50),                                             -- 关联的业务类型
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,                       -- 创建时间
        FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,         -- 外键关联用户表
        INDEX idx_user_id (user_id),                                          -- 为用户ID创建索引
        INDEX idx_change_type (change_type),                                  -- 为变动类型创建索引
        INDEX idx_created_at (created_at)                                     -- 为创建时间创建索引
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
    `;
    await connection.execute(createMoneyDetailsTable);
    console.log('✅ 资金明细表创建成功');

    // ====================
    // 创建卡交易记录表 (card_transactions)
    // 记录每张卡的交易流水，包括充值、消费、转账等
    // ====================
    const createCardTransactionsTable = `
      CREATE TABLE IF NOT EXISTS card_transactions (
        id INT AUTO_INCREMENT PRIMARY KEY,                                    -- 交易ID，自增主键
        card_id INT NOT NULL,                                                 -- 关联的卡片ID
        transaction_type ENUM('recharge', 'consumption', 'transfer') NOT NULL, -- 交易类型
        amount DECIMAL(15,2) NOT NULL,                                        -- 交易金额
        currency VARCHAR(10) NOT NULL DEFAULT 'USD',                          -- 交易货币
        merchant VARCHAR(255),                                                -- 商户名称
        description TEXT,                                                     -- 交易描述
        status ENUM('pending', 'completed', 'failed') DEFAULT 'pending',      -- 交易状态
        transaction_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,                 -- 交易时间
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,                       -- 创建时间
        FOREIGN KEY (card_id) REFERENCES cards(id) ON DELETE CASCADE,         -- 外键关联卡片表
        INDEX idx_card_id (card_id),                                          -- 为卡片ID创建索引
        INDEX idx_transaction_type (transaction_type),                        -- 为交易类型创建索引
        INDEX idx_status (status),                                            -- 为交易状态创建索引
        INDEX idx_transaction_date (transaction_date)                         -- 为交易时间创建索引
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
    `;
    await connection.execute(createCardTransactionsTable);
    console.log('✅ 卡交易记录表创建成功');

    // ====================
    // 创建充值审核记录表 (recharge_audits)
    // 记录充值记录的审核历史，支持多级审核
    // ====================
    const createRechargeAuditsTable = `
      CREATE TABLE IF NOT EXISTS recharge_audits (
        id INT AUTO_INCREMENT PRIMARY KEY,                                    -- 审核记录ID，自增主键
        recharge_id INT NOT NULL,                                             -- 关联的充值记录ID
        audit_status TINYINT DEFAULT 0 COMMENT '0:待审核, 1:通过, 2:驳回',     -- 审核状态
        audit_reason TEXT,                                                    -- 审核原因说明
        auditor_id INT,                                                       -- 审核人ID（可为空，系统自动审核）
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,                       -- 创建时间
        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, -- 更新时间
        FOREIGN KEY (recharge_id) REFERENCES recharges(id) ON DELETE CASCADE, -- 外键关联充值记录表
        INDEX idx_recharge_id (recharge_id),                                  -- 为充值记录ID创建索引
        INDEX idx_audit_status (audit_status),                                -- 为审核状态创建索引
        INDEX idx_created_at (created_at)                                     -- 为创建时间创建索引
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
    `;
    await connection.execute(createRechargeAuditsTable);
    console.log('✅ 充值审核记录表创建成功');

    // ====================
    // 创建卡BIN表 (card_bins)
    // 存储卡BIN（Bank Identification Number）信息，用于识别卡组织
    // ====================
    const createCardBinsTable = `
      CREATE TABLE IF NOT EXISTS card_bins (
        id INT AUTO_INCREMENT PRIMARY KEY,                    -- BIN记录ID，自增主键
        bin_value VARCHAR(10) UNIQUE NOT NULL,                -- BIN值（前6位卡号），唯一
        bin_label VARCHAR(100) NOT NULL,                      -- BIN描述标签
        card_scheme VARCHAR(50) NOT NULL,                     -- 卡组织名称（VISA/MasterCard等）
        is_active BOOLEAN DEFAULT TRUE,                       -- 是否激活该BIN
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,       -- 创建时间
        INDEX idx_bin_value (bin_value),                      -- 为BIN值创建索引
        INDEX idx_card_scheme (card_scheme),                  -- 为卡组织创建索引
        INDEX idx_is_active (is_active)                       -- 为激活状态创建索引
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
    `;
    await connection.execute(createCardBinsTable);
    console.log('✅ 卡BIN表创建成功');

    // ====================
    // 插入初始数据
    // ====================

    // 插入国家数据
    const countries = [
      { code: 'CN', name: '中国' },
      { code: 'US', name: '美国' },
      { code: 'JP', name: '日本' },
      { code: 'KR', name: '韩国' },
      { code: 'GB', name: '英国' },
      { code: 'DE', name: '德国' },
      { code: 'FR', name: '法国' },
      { code: 'CA', name: '加拿大' },
      { code: 'AU', name: '澳大利亚' },
      { code: 'BR', name: '巴西' }
    ];

    for (const country of countries) {
      await connection.execute(
        'INSERT IGNORE INTO countries (code, name) VALUES (?, ?)',
        [country.code, country.name]
      );
    }
    console.log('✅ 国家数据插入成功');

    // 插入持卡人允许国家数据（限制持卡人注册的国家）
    const allowedCountries = [
      { code: 'CN', name: '中国' },
      { code: 'US', name: '美国' },
      { code: 'GB', name: '英国' },
      { code: 'CA', name: '加拿大' },
      { code: 'AU', name: '澳大利亚' },
      { code: 'DE', name: '德国' },
      { code: 'FR', name: '法国' },
      { code: 'JP', name: '日本' },
      { code: 'KR', name: '韩国' },
      { code: 'SG', name: '新加坡' }
    ];

    for (const country of allowedCountries) {
      await connection.execute(
        'INSERT IGNORE INTO cardholder_allowed_countries (country_code) VALUES (?)',
        [country.code]
      );
    }
    console.log('✅ 持卡人允许国家数据插入成功');

    // 插入卡BIN数据
    const cardBins = [
      // VISA卡BIN（5个）
      { bin_value: '4111', bin_label: '4111 - VISA信用卡', card_scheme: 'VISA' },
      { bin_value: '4112', bin_label: '4112 - VISA信用卡', card_scheme: 'VISA' },
      { bin_value: '4113', bin_label: '4113 - VISA信用卡', card_scheme: 'VISA' },
      { bin_value: '4114', bin_label: '4114 - VISA信用卡', card_scheme: 'VISA' },
      { bin_value: '4115', bin_label: '4115 - VISA信用卡', card_scheme: 'VISA' },
      
      // MasterCard卡BIN（5个）
      { bin_value: '5112', bin_label: '5112 - MasterCard信用卡', card_scheme: 'MasterCard' },
      { bin_value: '5212', bin_label: '5212 - MasterCard信用卡', card_scheme: 'MasterCard' },
      { bin_value: '5312', bin_label: '5312 - MasterCard信用卡', card_scheme: 'MasterCard' },
      { bin_value: '5412', bin_label: '5412 - MasterCard信用卡', card_scheme: 'MasterCard' },
      { bin_value: '5512', bin_label: '5512 - MasterCard信用卡', card_scheme: 'MasterCard' },
      
      // Discover卡BIN（5个）
      { bin_value: '6011', bin_label: '6011 - Discover信用卡', card_scheme: 'Discover' },
      { bin_value: '6221', bin_label: '6221 - Discover信用卡', card_scheme: 'Discover' },
      { bin_value: '6441', bin_label: '6441 - Discover信用卡', card_scheme: 'Discover' },
      { bin_value: '6511', bin_label: '6511 - Discover信用卡', card_scheme: 'Discover' },
      { bin_value: '6521', bin_label: '6521 - Discover信用卡', card_scheme: 'Discover' }
    ];

    for (const bin of cardBins) {
      await connection.execute(
        'INSERT IGNORE INTO card_bins (bin_value, bin_label, card_scheme) VALUES (?, ?, ?)',
        [bin.bin_value, bin.bin_label, bin.card_scheme]
      );
    }
    console.log('✅ 卡BIN数据插入成功');

    /**
     * ====================
     * 第六步：插入测试数据
     * 为开发和测试环境插入完整的测试数据
     * ====================
     */

    // 插入测试用户（密码：123456）
    // 使用bcryptjs库对密码进行加密存储，确保安全性
    const bcrypt = require('bcryptjs');
    // 使用12轮盐值对密码进行哈希加密
    const hashedPassword = await bcrypt.hash('123456', 12);
    
    // 插入管理员测试用户
    await connection.execute(
      `INSERT IGNORE INTO users (username, email, password, country, name, is_active)
       VALUES (?, ?, ?, ?, ?, ?)`,
      ['admin', 'admin@example.com', hashedPassword, 'CN', '测试用户', true]
    );
    console.log('✅ 测试用户插入成功');

    // 获取测试用户ID
    const [users] = await connection.execute(
      'SELECT id FROM users WHERE username = ?',
      ['admin']
    );
    const userId = users[0].id;

    // 插入测试持卡人
    await connection.execute(
      `INSERT IGNORE INTO cardholders (
        cardholder_id, user_id, cardholder_name_abbreviation, first_name, last_name,
        first_name_abbr, last_name_abbr, email, mobile_prefix, mobile,
        date_of_birth, nationality_country_code, residential_country_code,
        residential_address, residential_city, residential_postal_code, residential_state,
        status
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
      [
        '12345678', // 测试cardholder_id
        userId,
        'ZHANG SAN',
        '三',
        '张',
        'S',
        'Z',
        'zhangsan@example.com',
        '+86',
        '13800138000',
        '1990-01-15',
        'CN',
        'CN',
        '北京市朝阳区建国路100号',
        '北京',
        '100000',
        '北京市',
        'normal' // 测试数据状态设为正常
      ]
    );
    console.log('✅ 测试持卡人插入成功');

    // 获取测试持卡人ID，用于关联卡片数据
    const [cardholders] = await connection.execute(
      'SELECT id FROM cardholders WHERE user_id = ?',
      [userId]
    );
    const cardholderId = cardholders[0].id;

    // 插入测试卡片（使用新的卡组织和卡BIN）
    // 第一张卡：VISA借记卡（虚拟卡）
    await connection.execute(
      `INSERT IGNORE INTO cards (
        user_id, cardholder_id, card_number, card_bin, card_type,
        card_form_factor, card_scheme, currency, balance, available_balance, card_status, nickname
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
      [
        userId,                    // 用户ID
        cardholderId,              // 持卡人ID
        '4111000012345678',        // 卡号（VISA卡号格式）
        '4111',                    // 卡BIN（VISA的BIN）
        'debit',                   // 卡类型：借记卡
        'virtual_card',            // 卡形式：虚拟卡
        'VISA',                    // 卡组织：VISA
        'USD',                     // 货币：美元
        500.00,                    // 总余额：500美元
        500.00,                    // 可用余额：500美元
        'normal',                  // 卡状态：可用
        '主卡'                     // 卡昵称
      ]
    );

    // 插入第二张测试卡片：MasterCard信用卡（实体卡）
    await connection.execute(
      `INSERT IGNORE INTO cards (
        user_id, cardholder_id, card_number, card_bin, card_type,
        card_form_factor, card_scheme, currency, balance, available_balance, card_status, nickname
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
      [
        userId,                    // 用户ID
        cardholderId,              // 持卡人ID
        '5112000098765432',        // 卡号（MasterCard卡号格式）
        '5112',                    // 卡BIN（MasterCard的BIN）
        'credit',                  // 卡类型：信用卡
        'physical_card',           // 卡形式：实体卡
        'MasterCard',              // 卡组织：MasterCard
        'USD',                     // 货币：美元
        1000.00,                   // 总余额：1000美元
        1000.00,                   // 可用余额：1000美元
        'normal',                  // 卡状态：可用
        '备用卡'                   // 卡昵称
      ]
    );

    // 插入第三张测试卡片（Discover）：Discover借记卡（虚拟卡）
    await connection.execute(
      `INSERT IGNORE INTO cards (
        user_id, cardholder_id, card_number, card_bin, card_type,
        card_form_factor, card_scheme, currency, balance, available_balance, card_status, nickname
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
      [
        userId,                    // 用户ID
        cardholderId,              // 持卡人ID
        '6011000033334444',        // 卡号（Discover卡号格式）
        '6011',                    // 卡BIN（Discover的BIN）
        'debit',                   // 卡类型：借记卡
        'virtual_card',            // 卡形式：虚拟卡
        'Discover',                // 卡组织：Discover
        'USD',                     // 货币：美元
        300.00,                    // 总余额：300美元
        300.00,                    // 可用余额：300美元
        'normal',                  // 卡状态：可用
        'Discover卡'               // 卡昵称
      ]
    );
    console.log('✅ 测试卡片插入成功');

    // 插入测试充值记录
    await connection.execute(
      `INSERT IGNORE INTO recharges (
        user_id, money, exchange_rate, money_cny, pay_type, audit_status
      ) VALUES (?, ?, ?, ?, ?, ?)`,
      [userId, 100.00, 6.85, 685.00, 1, 1]
    );

    await connection.execute(
      `INSERT IGNORE INTO recharges (
        user_id, money, exchange_rate, money_cny, pay_type, audit_status
      ) VALUES (?, ?, ?, ?, ?, ?)`,
      [userId, 200.00, 6.85, 1370.00, 2, 0]
    );
    console.log('✅ 测试充值记录插入成功');

    // 插入测试资金明细
    await connection.execute(
      `INSERT IGNORE INTO money_details (
        user_id, change_type, amount, balance, description
      ) VALUES (?, ?, ?, ?, ?)`,
      [userId, 1, 100.00, 100.00, '支付宝充值']
    );

    await connection.execute(
      `INSERT IGNORE INTO money_details (
        user_id, change_type, amount, balance, description
      ) VALUES (?, ?, ?, ?, ?)`,
      [userId, 1, 200.00, 300.00, '微信充值']
    );
    console.log('✅ 测试资金明细插入成功');

    // 插入测试卡交易记录
    const [cards] = await connection.execute(
      'SELECT id FROM cards WHERE user_id = ?',
      [userId]
    );
    const cardId1 = cards[0].id; // 第一张卡
    const cardId2 = cards[1].id; // 第二张卡

    // 为第一张卡添加交易记录
    await connection.execute(
      `INSERT IGNORE INTO card_transactions (
        card_id, transaction_type, amount, currency, merchant, description, status
      ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
      [cardId1, 'recharge', 100.00, 'USD', 'Bank Transfer', '账户充值', 'completed']
    );

    await connection.execute(
      `INSERT IGNORE INTO card_transactions (
        card_id, transaction_type, amount, currency, merchant, description, status
      ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
      [cardId1, 'consumption', 50.00, 'USD', 'Amazon', '网上购物', 'completed']
    );

    await connection.execute(
      `INSERT IGNORE INTO card_transactions (
        card_id, transaction_type, amount, currency, merchant, description, status
      ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
      [cardId1, 'consumption', 25.00, 'USD', 'Netflix', '订阅服务', 'completed']
    );

    await connection.execute(
      `INSERT IGNORE INTO card_transactions (
        card_id, transaction_type, amount, currency, merchant, description, status
      ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
      [cardId1, 'transfer', 75.00, 'USD', 'Internal Transfer', '内部转账', 'completed']
    );

    // 为第二张卡添加交易记录
    await connection.execute(
      `INSERT IGNORE INTO card_transactions (
        card_id, transaction_type, amount, currency, merchant, description, status
      ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
      [cardId2, 'recharge', 200.00, 'USD', 'Bank Transfer', '大额充值', 'completed']
    );

    await connection.execute(
      `INSERT IGNORE INTO card_transactions (
        card_id, transaction_type, amount, currency, merchant, description, status
      ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
      [cardId2, 'consumption', 100.00, 'USD', 'Apple Store', '购买设备', 'completed']
    );

    await connection.execute(
      `INSERT IGNORE INTO card_transactions (
        card_id, transaction_type, amount, currency, merchant, description, status
      ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
      [cardId2, 'consumption', 30.00, 'USD', 'Spotify', '音乐订阅', 'completed']
    );

    console.log('✅ 测试卡交易记录插入成功');

    // 添加更多资金明细记录
    await connection.execute(
      `INSERT IGNORE INTO money_details (
        user_id, change_type, amount, balance, description, related_id, related_type
      ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
      [userId, 2, 50.00, 250.00, '卡消费 - 卡ID:1', 1, 'card']
    );

    await connection.execute(
      `INSERT IGNORE INTO money_details (
        user_id, change_type, amount, balance, description, related_id, related_type
      ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
      [userId, 2, 25.00, 225.00, '卡消费 - 卡ID:1', 1, 'card']
    );

    await connection.execute(
      `INSERT IGNORE INTO money_details (
        user_id, change_type, amount, balance, description, related_id, related_type
      ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
      [userId, 3, 5.00, 220.00, '手续费 - 卡ID:1', 1, 'card']
    );

    await connection.execute(
      `INSERT IGNORE INTO money_details (
        user_id, change_type, amount, balance, description, related_id, related_type
      ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
      [userId, 4, 30.00, 250.00, '退款 - 卡ID:2', 2, 'card']
    );

    await connection.execute(
      `INSERT IGNORE INTO money_details (
        user_id, change_type, amount, balance, description, related_id, related_type
      ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
      [userId, 5, 100.00, 150.00, '卡消费 - 卡ID:2', 2, 'card']
    );

    console.log('✅ 测试资金明细记录插入成功');

    /**
     * ====================
     * 第七步：显示初始化结果
     * 打印详细的初始化结果，方便开发者了解系统状态
     * ====================
     */
    
    console.log('='.repeat(50));
    console.log('🎉 数据库初始化完成！');
    console.log('='.repeat(50));
    console.log('📊 数据库名称:', process.env.DB_NAME);
    console.log('👤 测试用户: admin');
    console.log('🔑 测试密码: 123456');
    console.log('👥 测试持卡人: 1个');
    console.log('💳 测试卡片: 3张'); // 更新为3张卡片
    console.log('💰 测试充值记录: 2条');
    console.log('📈 测试交易记录: 7条');
    console.log('📊 测试资金明细: 7条');
    console.log('='.repeat(50));

  } catch (error) {
    // 错误处理：如果初始化过程中出现任何错误，记录错误并退出程序
    console.error('❌ 数据库初始化失败:', error);
    process.exit(1); // 退出程序并返回错误代码1
  } finally {
    // 清理资源：无论成功还是失败，都要确保数据库连接被正确关闭
    if (connection) {
      await connection.end(); // 关闭数据库连接
    }
  }
}

/**
 * 直接运行检查
 * 如果这个文件被直接运行（而不是被其他模块导入），则执行初始化函数
 * require.main === module 判断当前模块是否是主模块（直接运行的模块）
 */
if (require.main === module) {
  initDatabase(); // 执行数据库初始化
}

// 导出初始化函数，供其他模块使用
module.exports = initDatabase;